home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / info / ilisp.info-1.z / ilisp.info-1
Encoding:
GNU Info File  |  1998-05-21  |  49.4 KB  |  1,404 lines
  1. This is Info file ../info/ilisp.info, produced by Makeinfo version 1.68
  2. from the input file ilisp.texi.
  3.  
  4.    This file documents ILISP.
  5.  
  6.    This is edition 0.12 of the ILISP manual for ILISP Version 5.8.
  7.  
  8.    Copyright (C) 1991,1992,1993 Todd Kaufmann               1993,1994
  9. Ivan Vasquez               1994, 1995, 1996 Marco Antoniotti and Rick
  10. Busdiecker               1996 Marco Antoniotti and Rick Campbell
  11.  
  12.    Permission is granted to make and distribute verbatim copies of this
  13. manual provided the copyright notice and this permission notice are
  14. preserved on all copies.
  15.  
  16.    Permission is granted to copy and distribute modified versions of
  17. this manual under the conditions for verbatim copying, provided that
  18. the entire resulting derived work is distributed under the terms of a
  19. permission notice identical to this one.
  20.  
  21.    Permission is granted to copy and distribute translations of this
  22. manual into another language, under the above conditions for modified
  23. versions, except that this permission notice may be stated in a
  24. translation approved by the Foundation.
  25.  
  26. 
  27. File: ilisp.info,  Node: Top,  Next: Distribution,  Prev: (dir),  Up: (dir)
  28.  
  29.    This Info file documents ILISP, a GNU Emacs interface for a lisp
  30. running in a buffer.
  31.  
  32. * Menu:
  33.  
  34. * Distribution::                How to get the latest ILISP distribution.
  35.  
  36. * Acknowledgements::            Acknowledgements
  37. * Introduction::                An introduction to ILISP and its features.
  38. * Installation::                How to install ILISP.
  39. * Starting up::                 How to run a Lisp process using ILISP.
  40.  
  41. * Buffers of ILISP::            Buffers used by ILISP, and their commands.
  42. * ILISP Commands::
  43. * Customization::               Description of ILISP variables and hooks.
  44. * Dialects::                    How ILISP knows how to communicate with Lisp,
  45.                                     and how to define new dialects.
  46.  
  47. Indices:
  48. * Concept index::               General concepts.
  49. * Key index::                   ILISP key sequences.
  50. * Command index::               Commands by name.
  51. * Variable index::              Variables and hooks that influence ILISP's
  52.                                    behavior.
  53.  
  54. * Function index::              Internal Emacs Lisp functions.
  55.  
  56. 
  57. File: ilisp.info,  Node: Distribution,  Next: Acknowledgements,  Prev: Top,  Up: Top
  58.  
  59. How to get the latest ILISP distribution.
  60. *****************************************
  61.  
  62.    ILISP is "free"; this means that everyone is free to use it and free
  63. to redistribute it on a free basis.  ILISP is not in the public domain;
  64. it is copyrighted and there are restrictions on its distribution, but
  65. these restrictions are designed to permit everything that a good
  66. cooperating citizen would want to do.  What is not allowed is to try to
  67. prevent others from further sharing any version of ILISP that they might
  68. get from you.  The precise conditions appears following this section.
  69.  
  70.    The easiest way to get a copy of ILISP is from someone else who has
  71. it.  You need not ask for permission to do so, or tell any one else;
  72. just copy it.
  73.  
  74.    If you do start using the package, please send mail to
  75. `ilisp-request@naggum.no' to subscribe to the ILISP mailing list.
  76.  
  77.    Please send bugs, questions or suggestions for discussion to
  78. `ilisp@naggum.no'.  Message sent there will be distributed to all
  79. subscribers.
  80.  
  81. * Menu:
  82.  
  83. * FTP directions::              FTP directions
  84. * WWW directions::              WWW directions
  85.  
  86. 
  87. File: ilisp.info,  Node: FTP directions,  Next: WWW directions,  Up: Distribution
  88.  
  89. FTP directions
  90. ==============
  91.  
  92. You can get the distribution file, `ilisp-5.8.tar.gz' via anonymous FTP
  93. from `FTP.CS.CMU.EDU' (128.2.206.173) in
  94. `/afs/cs/user/campbell/http/ilisp/'.
  95.  
  96. % "ftp ftp.cs.cmu.edu"
  97. Name (ftp.cs.cmu.edu:rickc): "anonymous"
  98. 331 Guest login ok, send username@node as password.
  99. Password: "YOUR-USER-ID@YOUR-HOSTNAME"
  100. ftp> "cd /afs/cs/user/campbell/http/ilisp"
  101. 250 Directory path set to /afs/cs/user/campbell/http/ilisp.
  102. ftp> "type binary"
  103. 200 Type set to I.
  104. ftp> "get ilisp-5.8.tar.gz"
  105. 200 PORT command successful.
  106. 150 Opening data connection for ilisp-5.8.tar.gz.
  107. 226 Transfer complete.
  108. local: ilisp-5.8.tar.gz remote: ilisp-5.8.tar.gz
  109. 168801 bytes received.
  110. ftp> "quit"
  111. 221 Goodbye.
  112.  
  113. Or get whatever single files you need from the `untarred' subdirectory.
  114.  
  115. You can also get `ilisp-5.8.tar.gz' via anonymous FTP from
  116. `FTP.ICSI.BERKELEY.EDU' in either `/pub/software/elisp/' or
  117. `/pub/theory/marcoxa/elisp/'.
  118.  
  119. Unpack and install:
  120.  
  121.    `% "gzip -dc ilisp-5.8.tar.gz | tar xf -"'
  122.  
  123.    *Note Installation::.
  124.  
  125. 
  126. File: ilisp.info,  Node: WWW directions,  Prev: FTP directions,  Up: Distribution
  127.  
  128. WWW directions
  129. ==============
  130.  
  131. You can use the World Wide Web (WWW) to get the distribution file from
  132. the anonymous FTP locations using one of the following URLs:
  133.    *
  134.  
  135.  
  136.  
  137.      `ftp://ftp.cs.cmu.edu/afs/cs/user/campbell/http/ilisp/ilisp-5.8.tar.gz'
  138.  
  139.    * `ftp://ftp.icsi.berkeley.edu/pub/software/elisp/ilisp-5.8.tar.gz'
  140.  
  141.    * `ftp://ftp.icsi.berkeley.edu/pub/theory/marcoxa/ilisp-5.8.tar.gz'
  142.  
  143.    You can also use the CMU Artificial Intelligence Repository:
  144.  
  145.    `http://www.cs.cmu.edu/Web/Groups/AI/html/repository.html'
  146.  
  147. From there follow: `LISP', `UTIL', `EMACS' and finally `ILISP'.  Use
  148. your browser capabilities to download what you need.
  149.  
  150. The complete URL for the distribution file in the CMU AI Repository is
  151. `http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/util/emacs/ilisp/v57/ilisp57.tgz'
  152.  
  153. Other URLs for the distribution file include:
  154.    * `http://www.c2.net/~campbell/ilisp/ilisp-5.8.tar.gz'
  155.  
  156.    * `http://www.cs.cmu.edu/~campbell/ilisp/ilisp-5.8.tar.gz'
  157.  
  158. Unpack and install:
  159.  
  160.    `% "gzip -dc ilisp-5.8.tar.gz | tar xf -"'
  161.  
  162.    *Note Installation::.
  163.  
  164. 
  165. File: ilisp.info,  Node: Acknowledgements,  Next: Introduction,  Prev: Distribution,  Up: Top
  166.  
  167. Acknowledgements
  168. ****************
  169.  
  170.    ILISP replaces the standard inferior LISP mode.  ILISP is based on
  171. comint mode and derived from a number of different interfaces including
  172. Symbolics, CMU Common Lisp, and Thinking Machines.
  173.  
  174.    There are many people that have taken the time to report bugs, make
  175. suggestions and even better send code to fix bugs or implement new
  176. features.
  177.  
  178.    Thanks to Guido Bosch, David Braunegg, Tim Bradshaw, Thomas M.
  179. Breuel, Hans Chalupsky, Kimball Collins, Brian Dennis, David Duff, Tom
  180. Emerson, Michael Ernst, Scott Fahlman, David Gadbois, Robert P.
  181. Goldman, Marty Hall, Richard Harris, Jim Healy, Christopher Hoover,
  182. Larry Hunter, Ben Hyde, Chuck Irvine, Michael Kashket, Mark Kantrowitz,
  183. Qiegang Long, Erik Naggum, Dan Pierson, Yusuf Pisan, Frank Ritter,
  184. Jeffrey Mark Siskind, Neil Smithline, Richard Stallman, Larry Stead,
  185. Jason Trenouth, Christof Ullwer, Bjorn Victor, Fred White, Ben Wing,
  186. Matsuo Yoshihiro, Jamie Zawinski, Paul Fuqua (for the CMU-CL GC display
  187. code) and Marco Antoniotti for bug reports, suggestions and code.  Our
  188. apologies to anyone we may have forgotten.
  189.  
  190.    Special thanks to Todd Kaufmann for the texinfo file, work on bridge,
  191. epoch-pop and for really exercising everything.
  192.  
  193.    Please send bug reports, fixes and extensions to `ilisp@naggum.no'
  194. so that they can be merged into the master source.
  195.  
  196.      --Chris McConnell                     18-Mar-91
  197.      --Ivan Vazquez                        27-Jun-93
  198.      --Marco Antoniotti and Rick Campbell  25-Oct-96
  199.  
  200. 
  201. File: ilisp.info,  Node: Introduction,  Next: Installation,  Prev: Acknowledgements,  Up: Top
  202.  
  203. Introduction
  204. ************
  205.  
  206.    ILISP is an interface from GNU Emacs to an inferior LISP.  It has the
  207. following features:
  208.  
  209.    * Runs under Emacs-18, Emacs-19, and XEmacs-19.
  210.  
  211.    * Support for multiple LISP dialects including Lucid, Allegro and CMU
  212.      on multiple machines even at the same time.
  213.  
  214.    * Dynamically sized pop-up windows that can be buried and scrolled
  215.      from any window.
  216.  
  217.    * Packages are properly handled including the distinction between
  218.      exported and internal symbols.
  219.  
  220.    * Synchronous, asynchronous or batch eval and compile of files,
  221.      regions, definitions and sexps with optional switching and
  222.      automatic calling.
  223.  
  224.    * Arglist, documentation, describe, inspect and macroexpand.
  225.  
  226.    * Completion of filename components and LISP symbols including
  227.      partial matches.
  228.  
  229.    * Find source both with and without help from the inferior LISP,
  230.      including CLOS methods, multiple definitions and multiple files.
  231.  
  232.    * Edit the callers of a function with and without help from the
  233.      inferior LISP.
  234.  
  235.    * Trace/untrace a function.
  236.  
  237.    * `M-q' ("Fill-paragraph") works properly on paragraphs in comments,
  238.      strings and code.
  239.  
  240.    * Find unbalanced parentheses.
  241.  
  242.    * Super brackets.
  243.  
  244.    * Handles editing, entering and indenting full LISP expressions.
  245.  
  246.    * Next, previous, and similar history mechanism compatible with
  247.      comint.
  248.  
  249.    * Handles LISP errors.
  250.  
  251.    * Result histories are maintained in the inferior LISP.
  252.  
  253.    * Does not create spurious symbols and handles case issues.
  254.  
  255.    * Online manuals for ILISP and Common LISP.
  256.  
  257. 
  258. File: ilisp.info,  Node: Installation,  Next: Starting up,  Prev: Introduction,  Up: Top
  259.  
  260. How to install ILISP
  261. ********************
  262.  
  263.    Installation of ILISP and some initialization of your computing
  264. environment are described in this chapter.  Please read the following
  265. sections carefully before getting started with ILISP.
  266.  
  267.    If ILISP has already been installed at your location, you can
  268. probably skip ahead to "Autoloading."
  269.  
  270.    Note that Jamie Zawinki's byte-compiler is required when compiling
  271. ILISP.  If you don't have it, get it from
  272. `ftp://archive.cis.ohio-state.edu/pub/gnu/emacs/elisp-archive/bytecomp2.tar.Z'
  273.  
  274.    You don't need it if you are running emacs version 19 as both the FSF
  275. and XEmacs releases include this in their distributions.
  276.  
  277. * Menu:
  278.  
  279. * Makefile configuration::
  280. * Files of ILISP::
  281. * Autoloading::                 How to define autoload entries.
  282.  
  283. 
  284. File: ilisp.info,  Node: Makefile configuration,  Next: Files of ILISP,  Up: Installation
  285.  
  286. Makefile configuration
  287. ======================
  288.  
  289.    Some configuration needs to be done before compiling the emacs-lisp
  290. files that comprise ILISP.  This should be done in the `Makefile' file
  291. in the section of the file marked CONFIGURATION SECTION.
  292.  
  293.    First, set the `YOUR_EMACS' variable to be the pathname of the emacs
  294. you will be using ILISP with.  This is the emacs that will be used to
  295. compile ILISP with.
  296.  
  297.    If you don't have Jamie Zawinski's byte compiler in your standard
  298. load path ( both FSF's 19 and XEmacs 19 do have enhaced versions of it )
  299. then you will have to uncomment the `BYTECOMP' line and set it to point
  300. to the correct location of the bytecomp files.
  301.  
  302.    If you do not have comint already in your emacs ( both FSF 19 and
  303. XEmacs 19 do ) then uncomment the `USE_BUNDLED_COMINT' line.  This will
  304. cause the copy of `comint.el' to be moved from the `Extras' directory
  305. into the main ILISP directory.
  306.  
  307.    The advice section is left uncommented out in the distributed
  308. `Makefile' because most people will not have `advice.elc' in their load
  309. path.  Only XEmacs will have this in the standard distribution.  If you
  310. do have it in your load path, then to avoid having two copies in your
  311. load-path and avoiding future confusion then comment out both the
  312. `ADVICE' and `USE_BUNDLED_ADVICE' lines.
  313.  
  314.    You can then compile everything with the shell command
  315.  
  316.    `% "make -f Makefile-ilisp "'"<YOUR TARGET HERE>"
  317.  
  318.    Where the possible targets are `emacs_18', `emacs_18_epoch',
  319. `emacs_18_menu', and `emacs_19'.
  320.  
  321.    Ignore any compilation warnings unless they result in ILISP not
  322. compiling completely.
  323.  
  324.    You should then copy relevant sections of `ilisp.emacs' to your
  325. `.emacs' or to the system-wide `default.el' file, depending on who will
  326. be using ILISP.
  327.  
  328.    You should add the directory where all of the ILISP emacs-lisp files
  329. reside to your `load-path'.  There is an example of this in
  330. `ilisp.emacs'
  331.  
  332.    As an alternative you could set up a `.ilisp' which contains the
  333. appropriate portions of `ilisp.emacs', in order to avoid cluttering too
  334. much `.emacs' or `default.el'
  335.  
  336.    The first time a dialect is started, the interface files will
  337. complain about not being compiled, just hit `i' to ignore the message.
  338. Once a lisp dialect is started up, you should execute the command
  339. `ilisp-compile-inits' which will compile the `*.lisp' files and write
  340. them to the same directory as the ilisp files.
  341.  
  342.    The binary files should have a unique extension for each different
  343. combination of architecture and LISP dialect.  You will need to change
  344. `ilisp-init-binary-extension' and `ilisp-init-binary-command' to get
  345. additional extensions.  The binary for each different architecture
  346. should be different.  If you want to build the interface files into a
  347. LISP world, you will also need to set `ilisp-load-inits' to `nil' in
  348. the same place that you change `ilisp-program' to load the LISP world.
  349.  
  350.    There is an `ilisp-site-hook' for initializing site specific stuff
  351. like program locations when ILISP is first loaded.  You may want to
  352. define appropriate autoloads in your system Emacs start up file.
  353.  
  354.    Example site init:
  355.      ;;; CMU site
  356.      (setq ilisp-site-hook
  357.            '(lambda ()
  358.              (setq ilisp-motd "CMU ILISP V%s")
  359.              (setq expand-symlinks-rfs-exists t)
  360.              (setq allegro-program "/usr/misc/.allegro/bin/cl")
  361.              (setq lucid-program "/usr/misc/.lucid/bin/lisp")))
  362.  
  363. 
  364. File: ilisp.info,  Node: Files of ILISP,  Next: Autoloading,  Prev: Makefile configuration,  Up: Installation
  365.  
  366. Files of ILISP
  367. ==============
  368.  
  369.    The files you need to use ilisp are:
  370.  
  371. `ilisp.emacs'
  372.      File with sample `.emacs' code for ILISP.
  373.  
  374. `symlink-fix.el'
  375.      Expand pathnames resolving links.
  376.  
  377. `completer.el'
  378.      Partial completion code.
  379.  
  380. `bridge.el'
  381.      Process to process communication.
  382.  
  383. `comint.el'
  384.      The basic comint abstraction.  You only need this if running
  385.      emacs-18.
  386.  
  387. `comint-ipc.el'
  388.      Extensions for sending commands and getting results.
  389.  
  390. `ilisp-ext.el'
  391.      Standalone lisp-mode extensions.
  392.  
  393. `ilisp-bug.el'
  394.      ILISP bug submittal code.
  395.  
  396. `compat.el'
  397.      Compatibility code between fsf-18, fsf-19 and lemacs-19.
  398.  
  399. `ilisp-inp.el'
  400.      Buffer input module.
  401.  
  402. `ilisp-def.el'
  403.      Variable definitions.
  404.  
  405. `ilisp-ind.el'
  406.      Indentation code.
  407.  
  408. `ilisp-mov.el'
  409.      Buffer-point movement code.
  410.  
  411. `ilisp-key.el'
  412.      Keymap setups, including `ilisp-lispm-bindings'.
  413.  
  414. `ilisp-doc.el'
  415.      ILISP mode documenation.
  416.  
  417. `ilisp-mod.el'
  418.      ILISP mode definition.
  419.  
  420. `ilisp-prn.el'
  421.      Parenthesis handling.
  422.  
  423. `ilisp-el.el'
  424.      Emacs-lisp additions.
  425.  
  426. `ilisp-sym.el'
  427.      ILISP symbol handling.
  428.  
  429. `ilisp-low.el'
  430.      Low level interface code.
  431.  
  432. `ilisp-hi.el'
  433.      High level interface code.
  434.  
  435. `ilisp-out.el'
  436.      Output handling, include typeout window (a popper replacement).
  437.  
  438. `ilisp-prc.el'
  439.      Process handling code.
  440.  
  441. `ilisp-val.el'
  442.      Buffer value interface.
  443.  
  444. `ilisp-rng.el'
  445.      Match ring code.
  446.  
  447. `ilisp-utl.el'
  448.      Misc. utilities.
  449.  
  450. `ilisp-hnd.el'
  451.      Error handling.
  452.  
  453. `ilisp-kil.el'
  454.      Interface to reset/kill/abort inferior lisp.
  455.  
  456. `ilisp-snd.el'
  457.      ilisp-send definitions and associated code.
  458.  
  459. `ilisp-cmt.el'
  460.      Comint related code/setup.
  461.  
  462. `ilisp-cmp.el'
  463.      ILISP completer related code.
  464.  
  465. `ilisp-xfr.el'
  466.      Transfer between lisp <-> emacs code.
  467.  
  468. `ilisp-cl.el'
  469.      Commo-Lisp dialect definition.
  470.  
  471. `ilisp-src.el'
  472.      ILISP source code module.
  473.  
  474. `ilisp-bat.el'
  475.      ILISP batch code module.
  476.  
  477. `ilisp.el'
  478.      File to be loaded, loads in all necessary parts of ILISP.
  479.  
  480. `*.lisp'
  481.      ILISP support code.  Each dialect will have one of these files.
  482.  
  483. `*.lcd'
  484.      Package descriptors for the Lisp Code Directory.
  485.  
  486. `ilisp.texi'
  487.      Texinfo file for ILISP.
  488.  
  489. 
  490. File: ilisp.info,  Node: Autoloading,  Prev: Files of ILISP,  Up: Installation
  491.  
  492. How to define autoload entries
  493. ==============================
  494.  
  495.    A complete example of things you may want to add to your `.emacs'
  496. can be found in the in the file `ilisp.emacs' in the `ilisp-directory'
  497. what follows is that file.
  498.  
  499.      ;;;
  500.      ;;; This file shows examples of some of the things you might want to
  501.      ;;; do to install or customize ILISP.  You may not want to include all
  502.      ;;; of them in your .emacs.  For example, the default key binding
  503.      ;;; prefix for ILISP is C-z and this file changes the default prefix to
  504.      ;;; C-c.  For more information on things that can be changed, see the
  505.      ;;; file ilisp.el.
  506.      ;;;
  507.      
  508.      ;;; If ilisp lives in some non-standard directory, you must tell emacs
  509.      ;;; where to get it. This may or may not be necessary.
  510.      (setq load-path (cons (expand-file-name "~jones/emacs/ilisp/") load-path))
  511.      
  512.      ;;; If you always want partial minibuffer completion
  513.      (require 'completer)
  514.      
  515.      ;;; If you want to redefine typeout-window keys:
  516.      (add-hook 'ilisp-load-hook
  517.            '(lambda ()
  518.          (define-key global-map "\C-c1" 'ilisp-bury-output)
  519.          (define-key global-map "\C-cv" 'ilisp-scroll-output)
  520.          (define-key global-map "\C-cg" 'ilisp-grow-output)))
  521.      
  522.      
  523.      (autoload 'run-ilisp "ilisp" "Select a new inferior LISP." t)
  524.      ;;; Autoload based on your LISP.  You only really need the one you use.
  525.      ;;; If called with a prefix, you will be prompted for a buffer and
  526.      ;;; program.
  527.      ;;;
  528.      ;;; [Back to the old way now -- Ivan Mon Jun 28 23:30:51 1993]
  529.      ;;;
  530.      (autoload 'clisp     "ilisp" "Inferior generic Common LISP." t)
  531.      (autoload 'allegro   "ilisp" "Inferior Allegro Common LISP." t)
  532.      (autoload 'lucid     "ilisp" "Inferior Lucid Common LISP." t)
  533.      (autoload 'cmulisp   "ilisp" "Inferior CMU Common LISP." t)
  534.      (autoload 'kcl       "ilisp" "Inferior Kyoto Common LISP." t)
  535.      (autoload 'akcl      "ilisp" "Inferior Austin Kyoto Common LISP." t)
  536.      (autoload 'ibcl      "ilisp" "Ibuki Common LISP." t)
  537.      (autoload 'scheme    "ilisp" "Inferior generic Scheme." t)
  538.      (autoload 'oaklisp   "ilisp" "Inferior Oaklisp Scheme." t)
  539.      
  540.      ;;; Define where LISP programs are found.  (This may already be done
  541.      ;;; at your site.)
  542.      (setq allegro-program "/usr/misc/.allegro/bin/cl")
  543.      (setq lucid-program "/usr/misc/.lucid/bin/lisp")
  544.      (setq cmulisp-program "/usr/misc/.cmucl/bin/lisp")
  545.      
  546.      ;;; If you run cmu-cl then set this to where your source files are.
  547.      (setq cmulisp-local-source-directory
  548.            "/usr/local/utils/CMU-CL/")
  549.      
  550.      
  551.      ;;; This makes reading a lisp file load in ilisp.
  552.      (set-default 'auto-mode-alist
  553.               (append '(("\\.lisp$" . lisp-mode)) auto-mode-alist))
  554.      (setq lisp-mode-hook '(lambda () (require 'ilisp)))
  555.      
  556.      ;;; Sample load hook
  557.      (add-hook 'ilisp-load-hook
  558.            '(lambda ()
  559.              ;; Change default key prefix to C-c
  560.              (setq ilisp-prefix "\C-c")
  561.      
  562.              ;; Define LispMachine-like key bindings, too.
  563.              (ilisp-lispm-bindings)
  564.      
  565.              ;; Sample initialization hook.  Set the inferior LISP directory to
  566.              ;; the directory of the buffer that spawned it on the first prompt.
  567.              (setq ilisp-init-hook
  568.               '(lambda ()
  569.                 (default-directory-lisp ilisp-last-buffer)))))
  570.  
  571. 
  572. File: ilisp.info,  Node: Starting up,  Next: Buffers of ILISP,  Prev: Installation,  Up: Top
  573.  
  574. How to run a Lisp process using ILISP
  575. *************************************
  576.  
  577.    To start a Lisp use `M-x run-ilisp', or a specific dialect like `M-x
  578. allegro'.  If called with a prefix you will be prompted for a buffer
  579. name and a program to run.  The default buffer name is the name of the
  580. dialect.  The default program for a dialect will be the value of
  581. DIALECT-program or the value of ilisp-program inherited from a less
  582. specific dialect.  If there are multiple LISP's, use the dialect name or
  583. `M-x select-ilisp' (`<C-z> S') to select the current ILISP buffer.
  584.  
  585.    Entry into ILISP mode runs the hooks on `comint-mode-hook' and
  586. `ilisp-mode-hook' and then DIALECT-hooks specific to LISP dialects in
  587. the nesting order above.  Many dialects call `ilisp-load-init' in their
  588. dialect setup.
  589.  
  590.    These are the currently supported dialects.
  591.  
  592.    * allegro Allegro Common Lisp from Franz Inc.
  593.  
  594.    * lispworks Harlequin Common Lisp from Harlequin Ltd.
  595.  
  596.    * lucid Lucid Common Lisp, currently supported by Harlequin Ltd.
  597.  
  598.    * kcl Kyoto Common Lisp, original version.
  599.  
  600.    * akcl Austin Kyoto Common Lisp, the U. Texas derivative.
  601.  
  602.    * gcl GNU Common Lisp, the official GNU release. A derivative of
  603.      AKCL.
  604.  
  605.    * ecl EcoLisp, the Embeddable Common Lisp by Beppe Attardi. A
  606.      derivative of KCL and AKCL.
  607.  
  608.    * ibcl Ibuki Common Lisp, derived from KCL.
  609.  
  610.    * cmucl CMU Common Lisp, the major development platform for ILISP so
  611.      far.
  612.  
  613.    * clisp-hs CLISP by Haible and Stoll.
  614.  
  615.    * oaklisp Oaklisp scheme.
  616.  
  617.    The dialects are listed so that the indentation correponds to the
  618. hierarchical relationship between dialects.
  619.       clisp
  620.         allegro
  621.         lucid
  622.         kcl
  623.           akcl
  624.             gcl
  625.             ecl
  626.           ibcl
  627.         cmulisp
  628.         clisp-hs
  629.         lispworks
  630.       scheme
  631.         oaklisp
  632.  
  633.    If anyone figures out support for other dialects I would be happy to
  634. include it in future releases.  *Note Dialects::.
  635.  
  636.    To define a new dialect, *Note Defining new dialects:: and *Note
  637. Customization::.
  638.  
  639. 
  640. File: ilisp.info,  Node: Buffers of ILISP,  Next: ILISP Commands,  Prev: Starting up,  Up: Top
  641.  
  642. Buffers used by ILISP, and their commands
  643. *****************************************
  644.  
  645. `*DIALECT*'
  646.      The Lisp listener buffer.  Forms can be entered in this buffer in,
  647.      and they will be sent to lisp when you hit return if the form is
  648.      complete.  This buffer is in ilisp-mode, which is built on top of
  649.      comint-mode, and all comint commands such as history mechanism and
  650.      job control are available.
  651.  
  652. `LISP-MODE-BUFFERS'
  653.      A buffer is assumed to contain Lisp source code if its major mode
  654.      is in the list `lisp-source-modes'.  If it's loaded into a buffer
  655.      that is in one of these major modes, it's considered a lisp source
  656.      file by `find-file-lisp', `load-file-lisp' and `compile-file-lisp'.
  657.      Used by these commands to determine defaults.
  658.  
  659. ``*Completions*''
  660.      Used for listing completions of symbols or files by the completion
  661.      commands.  *Note Completion::.
  662.  
  663. `*Aborted Commands*'
  664.      *Note Interrupts::.
  665.  
  666. `*Errors*'
  667. `*Output*'
  668. `*Error Output*'
  669.      used to pop-up results and errors from the inferior LISP.
  670.  
  671. `*ilisp-send*'
  672.      Buffer containing the last form sent to the inferior LISP.
  673.  
  674. `*Edit-Definitions*'
  675. `*All-Callers*'
  676.      *Note Source code commands::.
  677.  
  678. `*Last-Changes*'
  679. `*Changed-Definitions*'
  680.      *Note Batch commands::.
  681.  
  682. * Menu:
  683.  
  684. * Typeout windows::              temporary windows used for display.
  685. * Switching buffers::           Switching buffers
  686.  
  687. 
  688. File: ilisp.info,  Node: Typeout windows,  Next: Switching buffers,  Up: Buffers of ILISP
  689.  
  690. Typeout windows
  691. ===============
  692.  
  693.    All ILISP output is funneled through the function which is bound to
  694. the hook `ilisp-display-output-function'.  The function gets a single
  695. argument, a string, and should make that output visible to the user
  696. somehow.
  697.  
  698.    One possible choice for output display is
  699. `ilisp-display-output-in-typeout-window', which pops up a window at the
  700. top of the current screen which is just large enough to display the
  701. output.  This window can be "remote controlled" by the commands
  702. `ilisp-scroll-output', `ilisp-bury-output', and `ilisp-grow-output'.
  703.  
  704.    Unlike the old popper facility, the ilisp typeout window facility
  705. does not trounce on any existing Emacs functions or on any common key
  706. bindings, like `C-x o'.
  707.  
  708.    Other built-in functions which might be useful as values for
  709. `ilisp-display-output-function' include `ilisp-display-output-default',
  710. `ilisp-display-output-adaptively',
  711. `ilisp-display-output-in-lisp-listener',
  712. `ilisp-display-output-in-temp-buffer', and
  713. `ilisp-display-output-in-typeout-window'.
  714.  
  715.    The default display function is `ilisp-display-output-default',
  716. which obeys the `lisp-no-popper' variable.
  717.  
  718.    Users are encouraged to write their own output display functions to
  719. get the exact desired behavior, displaying on a private emacs screen,
  720. in a pop-up dialog box, or whetever.
  721.  
  722. `<C-z> 1   (ilisp-bury-output)'
  723.      deletes and buries the typeout output window.
  724.  
  725. `<C-z> v   (ilisp-scroll-output)'
  726.      scrolls the output window if it is showing, otherwise does nothing.
  727.      If it is called with a negative prefix, it will scroll backwards.
  728.  
  729. `<C-z> G   (ilisp-grow-output)'
  730.      will grow the output window if showing by the prefix number of
  731.      lines.
  732.  
  733.    An alternative to typeout windows is to always have the inferior LISP
  734. buffer visible and have all output go there.  Setting `lisp-no-popper'
  735. to `t' will cause all output to go to the inferior LISP buffer.
  736. Setting `lisp-no-popper' to `'message' will make output of one line go
  737. to the message window. Setting `comint-always-scroll' to `t' will cause
  738. process output to always be visible.  If a command gets an error, you
  739. will be left in the break loop.
  740.  
  741. 
  742. File: ilisp.info,  Node: Switching buffers,  Prev: Typeout windows,  Up: Buffers of ILISP
  743.  
  744. Switching buffers
  745. =================
  746.  
  747.    Commands to make switching between buffers easier.
  748.  
  749. `<C-z> b   (switch-to-lisp)'
  750.      will pop to the current ILISP buffer or if already in an ILISP
  751.      buffer, it will return to the buffer that last switched to an
  752.      ILISP buffer.  With a prefix, it will also go to the end of the
  753.      buffer.  If you do not want it to pop, set `pop-up-windows' to nil.
  754.  
  755. `M-C-l   (previous-buffer-lisp)'
  756.      will switch to the last visited buffer in the current window or
  757.      the Nth previous buffer with a prefix.
  758.  
  759. 
  760. File: ilisp.info,  Node: ILISP Commands,  Next: Customization,  Prev: Buffers of ILISP,  Up: Top
  761.  
  762. ILISP Commands
  763. **************
  764.  
  765.    Most of these key bindings work in both Lisp Mode and ILISP mode.
  766. There are a few additional and-go bindings found in Lisp Mode.
  767.  
  768. * Menu:
  769.  
  770. * Eval and compile functions::
  771. * Documentation functions::
  772. * Macroexpansion::
  773. * Tracing functions::
  774. * Package Commands::
  775. * Source code commands::        Working on several files
  776. * Batch commands::              Grouping changes for eval/compile
  777. * Files and directories::
  778. * Keyboard modes::              Interactive and raw keyboard modes
  779. * Interrupts::                  Interrupts, aborts, and errors
  780. * Command history::
  781. * Completion::
  782. * Miscellany::                  Indentation, parenthesis balancing,
  783.                   and comment commands.
  784.  
  785. 
  786. File: ilisp.info,  Node: Eval and compile functions,  Next: Documentation functions,  Up: ILISP Commands
  787.  
  788. Eval and compile functions
  789. ==========================
  790.  
  791.    In LISP, the major unit of interest is a form, which is anything
  792. between two matching parentheses.  Some of the commands here also refer
  793. to "defun," which is a list that starts at the left margin in a LISP
  794. buffer, or after a prompt in the ILISP buffer.  These commands refer to
  795. the "defun" that contains the point.
  796.  
  797.    "A call" refers to a reference to a function call for a function or
  798. macro, or a reference to a variable.  Commands which "insert a call" in
  799. the ILISP buffer will bring up the last command which matches it or
  800. else will insert a template for a call.
  801.  
  802.    When an eval is done of a single form matching `ilisp-defvar-regexp'
  803. the corresponding symbol will be unbound and the value assigned again.
  804.  
  805.    When you send a form to LISP, the status light will reflect the
  806. progress of the command.  In a lisp mode buffer the light will reflect
  807. the status of the currently selected inferior LISP unless
  808. `lisp-show-status' is nil.  If you want to find out what command is
  809. currently running, use the command `<C-z> s' (status-lisp).  If you
  810. call it with a prefix, the pending commands will be displayed as well.
  811.  
  812.    Note that in this table as elsewhere, the key <C-z> (ilisp-prefix)
  813. is used as a prefix character for ILISP commands, though this may be
  814. changed.  For a full list of key-bindings, use `M-x describe-mode' or
  815. `M-x describe-bindings' while in an ILISP-mode buffer.
  816.  
  817.    The eval/compile commands verify that their expressions are balanced
  818. and then send the form to the inferior LISP.  If called with a positive
  819. prefix, the result of the operation will be inserted into the buffer
  820. after the form that was just sent.
  821.  
  822.    For commands which operate on a region, the result of the compile or
  823. eval is the last form in the region.
  824.  
  825.    The `and-go' versions will perform the operation and then
  826. immediately switch to the ILISP buffer where you will see the results of
  827. executing your form.  If `eval-defun-and-go-lisp' or
  828. `compile-defun-and-go-lisp' is called with a prefix, a call for the
  829. form will be inserted as well.
  830.  
  831. `<C-z>'
  832.      The prefix-key for most ILISP commands.  This can be changed by
  833.      setting the variable `ilisp-prefix'.
  834.  
  835. `RET   (return-ilisp)'
  836.      In ILISP-mode buffer, sends the current form to lisp if complete,
  837.      otherwise creates a new line and indents.  If you edit old input,
  838.      the input will be copied to the end of the buffer first and then
  839.      sent.
  840.  
  841. `C-]   (close-and-send-lisp)'
  842.      Closes the current sexp, indents it, and then sends it to the
  843.      current inferior LISP.
  844.  
  845. `LFD   (newline-and-indent-lisp)'
  846.      Insert a new line and then indent to the appropriate level.  If
  847.      called at the end of the inferior LISP buffer and an sexp, the
  848.      sexp will be sent to the inferior LISP without a trailing newline.
  849.  
  850. `<C-z> e   (eval-defun-lisp)'
  851. `M-C-x   (eval-defun-lisp)'
  852. `<C-z> C-e   (eval-defun-and-go-lisp)'
  853.      Send the defun to lisp.
  854.  
  855. `<C-z> r   (eval-region-lisp)'
  856. `<C-z> C-r   (eval-region-and-go-lisp)'
  857.  
  858. `<C-z> n   (eval-next-sexp-lisp)'
  859. `<C-z> C-n   (eval-next-sexp-and-go-lisp)'
  860.  
  861. `<C-z> c   (compile-defun-lisp)'
  862.  
  863. `<C-z> C-c   (compile-defun-lisp-and-go)'
  864.      When `compile-defun-lisp' is called in an inferior LISP buffer with
  865.      no current form, the last form typed to the top-level will be
  866.      compiled.
  867.  
  868. `<C-z> w   (compile-region-lisp)'
  869. `<C-z> C-w   (compile-region-and-go-lisp)'
  870.    If any of the forms contain an interactive command, then the command
  871. will never return.  To get out of this state, you need to use
  872. `abort-commands-lisp' (`<C-z> g').  If `lisp-wait-p' is t, then EMACS
  873. will display the result of the command in the minibuffer or a pop-up
  874. window.  If `lisp-wait-p' is `nil', (the default) the send is done
  875. asynchronously and the results will be brought up only if there is more
  876. than one line or there is an error.  In this case, you will be given
  877. the option of ignoring the error, keeping it in another buffer or
  878. keeping it and aborting all pending sends.  If there is not a command
  879. already running in the inferior LISP, you can preserve the break loop.
  880. If called with a negative prefix, the sense of `lisp-wait-p' will be
  881. inverted for the next command.
  882.  
  883. 
  884. File: ilisp.info,  Node: Documentation functions,  Next: Macroexpansion,  Prev: Eval and compile functions,  Up: ILISP Commands
  885.  
  886. Documentation functions
  887. =======================
  888.  
  889.    `describe-lisp', `inspect-lisp', `arglist-lisp', and
  890. `documentation-lisp' switch whether they prompt for a response or use a
  891. default when called with a negative prefix.  If they are prompting,
  892. there is completion through the inferior LISP by using `TAB' or
  893. `M-TAB'.  When entering an expression in the minibuffer, all of the
  894. normal ilisp commands like `arglist-lisp' also work.
  895.  
  896.    Commands that work on a function will use the nearest previous
  897. function symbol.  This is either a symbol after a `#'' or the symbol at
  898. the start of the current list.
  899.  
  900. `<C-z> a   (arglist-lisp)'
  901.      Return the arglist of the current function.  With a numeric
  902.      prefix, the leading paren will be removed and the arglist will be
  903.      inserted into the buffer.
  904.  
  905. `<C-z> d   (documentation-lisp)'
  906.      Infers whether function or variable documentation is desired.
  907.      With a negative prefix, you can specify the type of documentation
  908.      as well.  With a positive prefix the documentation of the current
  909.      function call is inserted into the buffer.
  910.  
  911. `<C-z> i   (describe-lisp)'
  912.      Describe the previous sexp (it is evaluated).  If there is no
  913.      previous sexp and if called from inside an ILISP buffer, the
  914.      previous result will be described.
  915.  
  916. `<C-z> i   (describe-lisp)'
  917.      Describe the previous sexp (it is evaluated).  If there is no
  918.      previous sexp and if called from inside an ILISP buffer, the
  919.      previous result will be described.
  920.  
  921. `<C-z> I   (inspect-lisp)'
  922.      Switch to the current inferor LISP and inspect the previous sexp
  923.      (it is evaluated).  If there is no previous sexp and if called
  924.      from inside an ILISP buffer, the previous result will be inspected.
  925.  
  926. `<C-z> D   (fi:clman)'
  927. `<C-z> A   (fi:clman-apropos)'
  928.      If the Franz online Common LISP manual is available, get
  929.      information on a specific symbol.  `fi:clman-apropos' will get
  930.      information apropos a specific string.  Some of the documentation
  931.      is specific to the allegro dialect, but most of it is for standard
  932.      Common LISP.
  933.  
  934. 
  935. File: ilisp.info,  Node: Macroexpansion,  Next: Tracing functions,  Prev: Documentation functions,  Up: ILISP Commands
  936.  
  937. Macroexpansion
  938. ==============
  939.  
  940. `<C-z> M   (macroexpand-lisp)'
  941. `<C-z> m   (macroexpand-1-lisp)'
  942.      These commands apply to the next sexp.  If called with a positive
  943.      numeric prefix, the result of the macroexpansion will be inserted
  944.      into the buffer.  With a negative prefix, prompts for expression
  945.      to expand.
  946.  
  947. 
  948. File: ilisp.info,  Node: Tracing functions,  Next: Package Commands,  Prev: Macroexpansion,  Up: ILISP Commands
  949.  
  950. Tracing functions
  951. =================
  952.  
  953. `<C-z> t   (trace-defun-lisp)'
  954.      traces the current defun.   When called with a numeric prefix the
  955.      function will be untraced.  When called with negative prefix,
  956.      prompts for function to be traced.
  957.  
  958. 
  959. File: ilisp.info,  Node: Package Commands,  Next: Source code commands,  Prev: Tracing functions,  Up: ILISP Commands
  960.  
  961. Package Commands
  962. ================
  963.  
  964.    The first time an inferior LISP mode command is executed in a Lisp
  965. Mode buffer, the package will be determined by using the regular
  966. expression `ilisp-package-regexp' to find a package sexp and then
  967. passing that sexp to the inferior LISP through `ilisp-package-command'.
  968. For the `clisp' dialect, this will find the first `(in-package
  969. PACKAGE)' form in the file.  A buffer's package will be displayed in
  970. the mode line.  If a buffer has no specification, forms will be
  971. evaluated in the current inferior LISP package.
  972.  
  973.    Buffer package caching can be turned off by setting the variable
  974. `lisp-dont-cache-package' to `T'.  This will force ILISP to search for
  975. the closest previous `ilisp-package-regexp' in the buffer each time an
  976. inferior LISP mode command is executed.
  977.  
  978. `<C-z> p   (package-lisp)'
  979.      Show the current package of the inferior LISP.
  980.  
  981. `<C-z> P   (set-package-lisp)'
  982.      Set the inferior LISP package to the current buffer's package or
  983.      with a prefix to a manually entered package.
  984.  
  985. `M-x set-buffer-package-lisp'
  986.      Set the buffer's package from the buffer.  If it is called with a
  987.      prefix, the package can be set manually.
  988.  
  989. 
  990. File: ilisp.info,  Node: Source code commands,  Next: Batch commands,  Prev: Package Commands,  Up: ILISP Commands
  991.  
  992. Source Code Commands
  993. ====================
  994.  
  995.    The following commands all deal with finding things in source code.
  996. The first time that one of these commands is used, there may be some
  997. delay while the source module is loaded.  When searching files, the
  998. first applicable rule is used:
  999.    * try the inferior LISP,
  1000.  
  1001.    * try a tags file if defined,
  1002.  
  1003.    * try all buffers in one of `lisp-source-modes' or all files defined
  1004.      using `lisp-directory'.
  1005.  
  1006.    `M-x lisp-directory' defines a set of files to be searched by the
  1007. source code commands.  It prompts for a directory and sets the source
  1008. files to be those in the directory that match entries in
  1009. `auto-mode-alist' for modes in `lisp-source-modes'.  With a positive
  1010. prefix, the files are appended.  With a negative prefix, all current
  1011. buffers that are in one of `lisp-source-modes' will be searched.  This
  1012. is also what happens by default.  Using this command stops using a tags
  1013. file.
  1014.  
  1015.    `edit-definitions-lisp', `who-calls-lisp', and `edit-callers-lisp'
  1016. will switch whether they prompt for a response or use a default when
  1017. called with a negative prefix.  If they are prompting, there is
  1018. completion through the inferior LISP by using `TAB' or `M-TAB'.  When
  1019. entering an expression in the minibuffer, all of the normal ILISP
  1020. commands like `arglist-lisp' also work.
  1021.  
  1022.    `edit-definitions-lisp' (`M-.') will find a particular type of
  1023. definition for a symbol.  It tries to use the rules described above.
  1024. The files to be searched are listed in the buffer `*Edit-Definitions*'.
  1025. If `lisp-edit-files' is nil, no search will be done if not found
  1026. through the inferior LISP.  The variable `ilisp-locator' contains a
  1027. function that when given the name and type should be able to find the
  1028. appropriate definition in the file.  There is often a flag to cause
  1029. your LISP to record source files that you will need to set in the
  1030. initialization file for your LISP.  The variable is
  1031. `*record-source-files*' in both allegro and lucid.  Once a definition
  1032. has been found, `next-definition-lisp' (`M-,') will find the next
  1033. definition (or the previous definition with a prefix).
  1034.  
  1035.    `edit-callers-lisp' (`<C-z> ^') will generate a list of all of the
  1036. callers of a function in the current inferior LISP and edit the first
  1037. caller using `edit-definitions-lisp'.  Each successive call to
  1038. `next-caller-lisp' (`M-`') will edit the next caller (or the previous
  1039. caller with a prefix).  The list is stored in the buffer
  1040. `*All-Callers*'.  You can also look at the callers by doing `M-x
  1041. who-calls-lisp'.
  1042.  
  1043.    `search-lisp' (`M-?') will search the current tags files,
  1044. `lisp-directory' files or buffers in one of `lisp-source-modes' for a
  1045. string or a regular expression when called with a prefix.
  1046. `next-definition-lisp' (`M-,') will find the next definition (or the
  1047. previous definition with a prefix).
  1048.  
  1049.    `replace-lisp' (`M-"') will replace a string (or a regexp with a
  1050. prefix) in the current tags files, `lisp-directory' files or buffers in
  1051. one of `lisp-source-modes'.
  1052.  
  1053.    Here is a summary of the above commands (behavior when given prefix
  1054. argument is given in parentheses):
  1055.  
  1056. `M-x lisp-directory'
  1057.      Define a set of files to be used by the source code commands.
  1058.  
  1059. `M-.   (edit-definitions-lisp)'
  1060.      Find definition of a symbol.
  1061.  
  1062. `M-,   (next-definition-lisp)'
  1063.      Find next (previous) definition.
  1064.  
  1065. `<C-z> ^   (edit-callers-lisp)'
  1066.      Find all callers of a function, and edit the first.
  1067.  
  1068. `M-`   (next-caller-lisp)'
  1069.      Edit next (previous) caller of function set by `edit-callers-lisp'.
  1070.  
  1071. `M-x who-calls-lisp'
  1072.      List all the callers of a function.
  1073.  
  1074. `M-?   (search-lisp)'
  1075.      Search for string (regular expression) in current tags,
  1076.      `lisp-directory' files or buffers.  Use `next-definition-lisp' to
  1077.      find next occurence.
  1078.  
  1079. `M-"   (replace-lisp)'
  1080.      Replace a string (regular expression) in files.
  1081.  
  1082. 
  1083. File: ilisp.info,  Node: Batch commands,  Next: Files and directories,  Prev: Source code commands,  Up: ILISP Commands
  1084.  
  1085. Batch commands
  1086. ==============
  1087.  
  1088.    The following commands all deal with making a number of changes all
  1089. at once.  The first time one of these commands is used, there may be
  1090. some delay as the module is loaded.  The eval/compile versions of these
  1091. commands are always executed asynchronously.
  1092.  
  1093.    `mark-change-lisp' (`<C-z> SPC') marks the current defun as being
  1094. changed.  A prefix causes it to be unmarked.  `clear-changes-lisp'
  1095. (`<C-z> * 0') will clear all of the changes.  `list-changes-lisp'
  1096. (`<C-z> * l') will show the forms currently marked.
  1097.  
  1098.    `eval-changes-lisp' (`<C-z> * e'), or `compile-changes-lisp' (`<C-z>
  1099. * c') will evaluate or compile these changes as appropriate.  If called
  1100. with a positive prefix, the changes will be kept.  If there is an
  1101. error, the process will stop and show the error and all remaining
  1102. changes will remain in the list.  All of the results will be kept in
  1103. the buffer `*Last-Changes*'.
  1104.  
  1105. Summary:
  1106.  
  1107. `<C-z> SPC   (mark-change-lisp)'
  1108.      Mark (unmark) current defun as changed.
  1109.  
  1110. `<C-z> * e   (eval-changes-lisp)'
  1111. `<C-z> * c   (compile-changes-lisp)'
  1112.      Call with a positive prefix to keep changes.
  1113.  
  1114. `<C-z> * 0   (clear-changes-lisp)'
  1115.  
  1116. `<C-z> * l   (list-changes-lisp)'
  1117. 
  1118. File: ilisp.info,  Node: Files and directories,  Next: Keyboard modes,  Prev: Batch commands,  Up: ILISP Commands
  1119.  
  1120. Files and directories
  1121. =====================
  1122.  
  1123.    File commands in lisp-source-mode buffers keep track of the last used
  1124. directory and file.  If the point is on a string, that will be the
  1125. default if the file exists.  If the buffer is one of
  1126. `lisp-source-modes', the buffer file will be the default.  Otherwise,
  1127. the last file used in a lisp-source-mode will be used.
  1128.  
  1129. `C-x C-f   (find-file-lisp)'
  1130.      will find a file.  If it is in a string, that will be used as the
  1131.      default if it matches an existing file.  Symbolic links are
  1132.      expanded so that different references to the same file will end up
  1133.      with the same buffer.
  1134.  
  1135. `<C-z> l   (load-file-lisp)'
  1136.      will load a file into the inferior LISP.  You will be given the
  1137.      opportunity to save the buffer if it has changed and to compile
  1138.      the file if the compiled version is older than the current version.
  1139.  
  1140. `<C-z> k   (compile-file-lisp)'
  1141.      will compile a file in the current inferior LISP.
  1142.  
  1143. `<C-z> !   (default-directory-lisp)'
  1144.      sets the default inferior LISP directory to the directory of the
  1145.      current buffer.  If called in an inferior LISP buffer, it sets the
  1146.      Emacs `default-directory' to the LISP default directory.
  1147.  
  1148. 
  1149. File: ilisp.info,  Node: Keyboard modes,  Next: Interrupts,  Prev: Files and directories,  Up: ILISP Commands
  1150.  
  1151. Switching between interactive and raw keyboard modes
  1152. ====================================================
  1153.  
  1154.    There are two keyboard modes for interacting with the inferior LISP,
  1155. \"interactive\" and \"raw\".  Normally you are in interactive mode
  1156. where keys are interpreted as commands to EMACS and nothing is sent to
  1157. the inferior LISP unless a specific command does so.  In raw mode, all
  1158. characters are passed directly to the inferior LISP without any
  1159. interpretation as EMACS commands.  Keys will not be echoed unless
  1160. ilisp-raw-echo is T.
  1161.  
  1162.    Raw mode can be turned on interactively by the command
  1163. `raw-keys-ilisp' (`<C-z> #') and will continue until you type <C-g>.
  1164. Raw mode can also be turned on/off by inferior LISP functions if the
  1165. command `io-bridge-ilisp' (M-x io-bridge-ilisp) has been executed in
  1166. the inferior LISP either interactively or on a hook.  To turn on raw
  1167. mode, a function should print ^[1^] and to turn it off should print
  1168. ^[0^].  An example in Common LISP would be:
  1169.  
  1170.    `(progn (format t "") (print (read-char)) (format t ""))'
  1171.  
  1172. 
  1173. File: ilisp.info,  Node: Interrupts,  Next: Command history,  Prev: Keyboard modes,  Up: ILISP Commands
  1174.  
  1175. Interrupts, aborts, and errors
  1176. ==============================
  1177.  
  1178.    If you want to abort the last command you can use `C-g'.
  1179.  
  1180.    If you want to abort all commands, you should use the command
  1181. `abort-commands-lisp' (`<C-z> g').  Commands that are aborted will be
  1182. put in the buffer `*Aborted Commands*' so that you can see what was
  1183. aborted.  If you want to abort the currently running top-level command,
  1184. use `interrupt-subjob-ilisp' (`C-c C-c').  As a last resort, `M-x
  1185. panic-lisp' will reset the ILISP state without affecting the inferior
  1186. LISP so that you can see what is happening.
  1187.  
  1188.    `delete-char-or-pop-ilisp' (`C-d') will delete prefix characters
  1189. unless you are at the end of an ILISP buffer in which case it will pop
  1190. one level in the break loop.
  1191.  
  1192.    `reset-ilisp', (`<C-z> z') will reset the current inferior LISP's
  1193. top-level so that it will no longer be in a break loop.
  1194.  
  1195.    Summary:
  1196.  
  1197. `C-c C-c   (interrupt-subjob-ilisp)'
  1198.      Send a keyboard interrupt signal to lisp.
  1199.  
  1200. `<C-z> g    (abort-commands-lisp)'
  1201.      Abort all running or unsent commands.
  1202.  
  1203. `M-x panic-lisp (panic-lisp)'
  1204.      Reset the ILISP process state.
  1205.  
  1206. `<C-z> z   (reset-ilisp)'
  1207.      Reset lisp to top-level.
  1208.  
  1209. `C-d   (delete-char-or-pop-ilisp)'
  1210.      If at end of buffer, pop a level in break loop.
  1211.  
  1212.    If `lisp-wait-p' is `nil'  (the default), all sends are done
  1213. asynchronously and the results will be brought up only if there is more
  1214. than one line or there is an error.  In case, you will be given the
  1215. option of ignoring the error, keeping it in another buffer or keeping
  1216. it and aborting all pending sends.  If there is not a command already
  1217. running in the inferior LISP, you can preserve the break loop.  If
  1218. called with a negative prefix, the sense of `lisp-wait-p' will be
  1219. inverted for the next command.
  1220.  
  1221. 
  1222. File: ilisp.info,  Node: Command history,  Next: Completion,  Prev: Interrupts,  Up: ILISP Commands
  1223.  
  1224. Command history
  1225. ===============
  1226.  
  1227.    ILISP mode is built on top of `comint-mode', the general
  1228. command-interpreter-in-a-buffer mode.  As such, it inherits many
  1229. commands and features from this, including a command history mechanism.
  1230.  
  1231.    Each ILISP buffer has a command history associated with it.  Commands
  1232. that do not match `ilisp-filter-regexp' and that are longer than
  1233. `ilisp-filter-length' and that do not match the immediately prior
  1234. command will be added to this history.
  1235.  
  1236. `M-n   (comint-next-input)'
  1237. `M-p   (comint-previous-input)'
  1238.      Cycle through the input history.
  1239.  
  1240. `M-s    (comint-previous-similar-input)'
  1241.      Cycle through input that has the string typed so far as a prefix.
  1242.  
  1243. `M-N    (comint-psearch-input)'
  1244.      Search forwards for prompt.
  1245.  
  1246. `M-P    (comint-msearch-input)'
  1247.      Search backwards for prompt.
  1248.  
  1249. `C-c R   (comint-msearch-input-matching)'
  1250.      Search backwards for occurrence of prompt followed by string which
  1251.      is prompted for (*not* a regular expression).
  1252.  
  1253.    See `comint-mode' documentation for more information on `comint'
  1254. commands.
  1255.  
  1256. 
  1257. File: ilisp.info,  Node: Completion,  Next: Miscellany,  Prev: Command history,  Up: ILISP Commands
  1258.  
  1259. Completion
  1260. ==========
  1261.  
  1262.    Commands to reduce number of keystrokes.
  1263.  
  1264. `M-TAB   (complete-lisp)'
  1265.      will try to complete the previous symbol in the current inferior
  1266.      LISP.  Partial completion is supported unless `ilisp-prefix-match'
  1267.      is set to `t'.  (If you set it to `t', inferior LISP completions
  1268.      will be faster.)  With partial completion, `p--n' would complete to
  1269.      `position-if-not' in Common LISP.  If the symbol follows a left
  1270.      paren or a `#'', only symbols with function cells will be
  1271.      considered.  If the symbol starts with a `*' or you call with a
  1272.      positive prefix all possible completions will be considered.  Only
  1273.      external symbols are considered if there is a package qualification
  1274.      with only one colon.  The first time you try to complete a string
  1275.      the longest common substring will be inserted and the cursor will
  1276.      be left on the point of ambiguity.  If you try to complete again,
  1277.      you can see the possible completions.  If you are in a string,
  1278.      then filename completion will be done instead.  And if you try to
  1279.      complete a filename twice, you will see a list of possible
  1280.      completions.  Filename components are completed individually, so
  1281.      `/u/mi/' could expand to `/usr/misc/'.  If you complete with a
  1282.      negative prefix, the most recent completion (symbol or filename)
  1283.      will be undone.
  1284.  
  1285. `M-RET   (complete)'
  1286.      will complete the current symbol to the most recently seen symbol
  1287.      in Emacs that matches what you have typed so far.  Executing it
  1288.      repeatedly will cycle through potential matches.  This is from the
  1289.      TMC completion package and there may be some delay as it is
  1290.      initially loaded.
  1291.  
  1292. 
  1293. File: ilisp.info,  Node: Miscellany,  Prev: Completion,  Up: ILISP Commands
  1294.  
  1295. Miscellany
  1296. ==========
  1297.  
  1298.    Indentation, parenthesis balancing, and comment commands.
  1299.  
  1300. `TAB   (indent-line-ilisp)'
  1301.      indents for LISP.  With prefix, shifts rest of expression rigidly
  1302.      with the current line.
  1303.  
  1304. `M-C-q   (indent-sexp-ilisp)'
  1305.      will indent each line in the next sexp.
  1306.  
  1307. `M-q   (reindent-lisp)'
  1308.      will reindent the current paragraph if in a comment or string.
  1309.      Otherwise it will close the containing defun and reindent it.
  1310.  
  1311. `<C-z> ;   (comment-region-lisp)'
  1312.      will put prefix copies of `comment-start' before and
  1313.      `comment-end''s after the lines in region.  To uncomment a region,
  1314.      use a minus prefix.
  1315.  
  1316. `<C-z> )   (find-unbalanced-lisp)'
  1317.      will find unbalanced parens in the current buffer.  When called
  1318.      with a prefix it will look in the current region.
  1319.  
  1320. `]   (close-all-lisp)'
  1321.      will close all outstanding parens back to the containing form, or a
  1322.      previous left bracket which will be converted to a left parens.  If
  1323.      there are too many parens, they will be deleted unless there is
  1324.      text between the last paren and the end of the defun.  If called
  1325.      with a prefix, all open left brackets will be closed.
  1326.  
  1327. 
  1328. File: ilisp.info,  Node: Customization,  Next: Dialects,  Prev: ILISP Commands,  Up: Top
  1329.  
  1330. ILISP Customization
  1331. *******************
  1332.  
  1333.    Starting a dialect runs the hooks on `comint-mode-hook' and
  1334. `ilisp-mode-hook' and then DIALECT`-hooks' specific to dialects in the
  1335. nesting order below.
  1336.       clisp
  1337.         allegro
  1338.         lucid
  1339.         kcl
  1340.           akcl
  1341.           ibcl
  1342.         cmulisp
  1343.       scheme
  1344.         oaklisp
  1345.  
  1346.    On the very first prompt in the inferior LISP, the hooks on
  1347. `ilisp-init-hook' are run.  For more information on creating a new
  1348. dialect or variables to set in hooks, see `ilisp.el'.
  1349.  
  1350.    ILISP Mode Hooks:
  1351. `ilisp-site-hook'
  1352.      Executed when file is loaded
  1353.  
  1354. `ilisp-load-hook'
  1355.      Executed when file is loaded
  1356.  
  1357. `ilisp-mode-hook'
  1358.      Executed when an ilisp buffer is created
  1359.  
  1360. `ilisp-init-hook'
  1361.      Executed after inferior LISP is initialized and the first prompt is
  1362.      seen.
  1363.  
  1364. `DIALECT-hook'
  1365.      Executed when dialect is set
  1366.  
  1367.    Variables you might want to set in a hook or dialect:
  1368. `ilisp-prefix'
  1369.      Keys to prefix ilisp key bindings
  1370.  
  1371. `ilisp-program'
  1372.      Program to start for inferior LISP
  1373.  
  1374. `ilisp-motd'
  1375.      String printed on startup with version
  1376.  
  1377. `lisp-wait-p'
  1378.      Set to T for synchronous sends
  1379.  
  1380. `ilisp-handle-errors'
  1381.      Set to T for ilisp to handle errors from the underlying lisp.
  1382.  
  1383. `ilisp-display-output-function'
  1384.      The name of a function which displays ILISP output.
  1385.  
  1386. `lisp-no-popper'
  1387.      Set to T to have all output in inferior LISP
  1388.  
  1389. `lisp-show-status'
  1390.      Set to nil to stop showing process status
  1391.  
  1392. `ilisp-prefix-match'
  1393.      Set to T if you do not want partial completion
  1394.  
  1395. `ilisp-filter-regexp'
  1396.      Input history filter
  1397.  
  1398. `ilisp-filter-length'
  1399.      Input history minimum length
  1400.  
  1401. `ilisp-other-prompt'
  1402.      Prompt for non- top-level read-eval print loops
  1403.  
  1404.